home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / gettext.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  14KB  |  599 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import locale
  5. import copy
  6. import os
  7. import re
  8. import struct
  9. import sys
  10. from errno import ENOENT
  11. __all__ = [
  12.     'NullTranslations',
  13.     'GNUTranslations',
  14.     'Catalog',
  15.     'find',
  16.     'translation',
  17.     'install',
  18.     'textdomain',
  19.     'bindtextdomain',
  20.     'dgettext',
  21.     'dngettext',
  22.     'gettext',
  23.     'ngettext']
  24. _default_localedir = os.path.join(sys.prefix, 'share', 'locale')
  25.  
  26. def test(condition, true, false):
  27.     if condition:
  28.         return true
  29.     else:
  30.         return false
  31.  
  32.  
  33. def c2py(plural):
  34.     
  35.     try:
  36.         StringIO = StringIO
  37.         import cStringIO
  38.     except ImportError:
  39.         StringIO = StringIO
  40.         import StringIO
  41.  
  42.     import token as token
  43.     import tokenize as tokenize
  44.     tokens = tokenize.generate_tokens(StringIO(plural).readline)
  45.     
  46.     try:
  47.         danger = _[1]
  48.     except tokenize.TokenError:
  49.         raise ValueError, 'plural forms expression error, maybe unbalanced parenthesis'
  50.  
  51.     if danger:
  52.         raise ValueError, 'plural forms expression could be dangerous'
  53.     
  54.     plural = plural.replace('&&', ' and ')
  55.     plural = plural.replace('||', ' or ')
  56.     expr = re.compile('\\!([^=])')
  57.     plural = expr.sub(' not \\1', plural)
  58.     expr = re.compile('(.*?)\\?(.*?):(.*)')
  59.     
  60.     def repl(x):
  61.         return 'test(%s, %s, %s)' % (x.group(1), x.group(2), expr.sub(repl, x.group(3)))
  62.  
  63.     stack = [
  64.         '']
  65.     for c in plural:
  66.         if c == '(':
  67.             stack.append('')
  68.             continue
  69.         (None, None)
  70.         if c == ')':
  71.             if len(stack) == 1:
  72.                 raise ValueError, 'unbalanced parenthesis in plural form'
  73.             
  74.             s = expr.sub(repl, stack.pop())
  75.             stack[-1] += '(%s)' % s
  76.             continue
  77.         stack[-1] += c
  78.     
  79.     plural = expr.sub(repl, stack.pop())
  80.     return eval('lambda n: int(%s)' % plural)
  81.  
  82.  
  83. def _expand_lang(locale):
  84.     normalize = normalize
  85.     import locale
  86.     locale = normalize(locale)
  87.     COMPONENT_CODESET = 1
  88.     COMPONENT_TERRITORY = 2
  89.     COMPONENT_MODIFIER = 4
  90.     mask = 0
  91.     pos = locale.find('@')
  92.     if pos >= 0:
  93.         modifier = locale[pos:]
  94.         locale = locale[:pos]
  95.         mask |= COMPONENT_MODIFIER
  96.     else:
  97.         modifier = ''
  98.     pos = locale.find('.')
  99.     if pos >= 0:
  100.         codeset = locale[pos:]
  101.         locale = locale[:pos]
  102.         mask |= COMPONENT_CODESET
  103.     else:
  104.         codeset = ''
  105.     pos = locale.find('_')
  106.     if pos >= 0:
  107.         territory = locale[pos:]
  108.         locale = locale[:pos]
  109.         mask |= COMPONENT_TERRITORY
  110.     else:
  111.         territory = ''
  112.     language = locale
  113.     ret = []
  114.     for i in range(mask + 1):
  115.         if not i & ~mask:
  116.             val = language
  117.             if i & COMPONENT_TERRITORY:
  118.                 val += territory
  119.             
  120.             if i & COMPONENT_CODESET:
  121.                 val += codeset
  122.             
  123.             if i & COMPONENT_MODIFIER:
  124.                 val += modifier
  125.             
  126.             ret.append(val)
  127.             continue
  128.     
  129.     ret.reverse()
  130.     return ret
  131.  
  132.  
  133. class NullTranslations:
  134.     
  135.     def __init__(self, fp = None):
  136.         self._info = { }
  137.         self._charset = None
  138.         self._output_charset = None
  139.         self._fallback = None
  140.         if fp is not None:
  141.             self._parse(fp)
  142.         
  143.  
  144.     
  145.     def _parse(self, fp):
  146.         pass
  147.  
  148.     
  149.     def add_fallback(self, fallback):
  150.         if self._fallback:
  151.             self._fallback.add_fallback(fallback)
  152.         else:
  153.             self._fallback = fallback
  154.  
  155.     
  156.     def gettext(self, message):
  157.         if self._fallback:
  158.             return self._fallback.gettext(message)
  159.         
  160.         return message
  161.  
  162.     
  163.     def lgettext(self, message):
  164.         if self._fallback:
  165.             return self._fallback.lgettext(message)
  166.         
  167.         return message
  168.  
  169.     
  170.     def ngettext(self, msgid1, msgid2, n):
  171.         if self._fallback:
  172.             return self._fallback.ngettext(msgid1, msgid2, n)
  173.         
  174.         if n == 1:
  175.             return msgid1
  176.         else:
  177.             return msgid2
  178.  
  179.     
  180.     def lngettext(self, msgid1, msgid2, n):
  181.         if self._fallback:
  182.             return self._fallback.lngettext(msgid1, msgid2, n)
  183.         
  184.         if n == 1:
  185.             return msgid1
  186.         else:
  187.             return msgid2
  188.  
  189.     
  190.     def ugettext(self, message):
  191.         if self._fallback:
  192.             return self._fallback.ugettext(message)
  193.         
  194.         return unicode(message)
  195.  
  196.     
  197.     def ungettext(self, msgid1, msgid2, n):
  198.         if self._fallback:
  199.             return self._fallback.ungettext(msgid1, msgid2, n)
  200.         
  201.         if n == 1:
  202.             return unicode(msgid1)
  203.         else:
  204.             return unicode(msgid2)
  205.  
  206.     
  207.     def info(self):
  208.         return self._info
  209.  
  210.     
  211.     def charset(self):
  212.         return self._charset
  213.  
  214.     
  215.     def output_charset(self):
  216.         return self._output_charset
  217.  
  218.     
  219.     def set_output_charset(self, charset):
  220.         self._output_charset = charset
  221.  
  222.     
  223.     def install(self, unicode = False, names = None):
  224.         import __builtin__ as __builtin__
  225.         if not unicode or self.ugettext:
  226.             pass
  227.         __builtin__.__dict__['_'] = self.gettext
  228.         if hasattr(names, '__contains__'):
  229.             if 'gettext' in names:
  230.                 __builtin__.__dict__['gettext'] = __builtin__.__dict__['_']
  231.             
  232.             if 'ngettext' in names:
  233.                 if not unicode or self.ungettext:
  234.                     pass
  235.                 __builtin__.__dict__['ngettext'] = self.ngettext
  236.             
  237.             if 'lgettext' in names:
  238.                 __builtin__.__dict__['lgettext'] = self.lgettext
  239.             
  240.             if 'lngettext' in names:
  241.                 __builtin__.__dict__['lngettext'] = self.lngettext
  242.             
  243.         
  244.  
  245.  
  246.  
  247. class GNUTranslations(NullTranslations):
  248.     LE_MAGIC = 0x950412DEL
  249.     BE_MAGIC = 0xDE120495L
  250.     
  251.     def _parse(self, fp):
  252.         unpack = struct.unpack
  253.         filename = getattr(fp, 'name', '')
  254.         self._catalog = catalog = { }
  255.         
  256.         self.plural = lambda n: int(n != 1)
  257.         buf = fp.read()
  258.         buflen = len(buf)
  259.         magic = unpack('<I', buf[:4])[0]
  260.         if magic == self.LE_MAGIC:
  261.             (version, msgcount, masteridx, transidx) = unpack('<4I', buf[4:20])
  262.             ii = '<II'
  263.         elif magic == self.BE_MAGIC:
  264.             (version, msgcount, masteridx, transidx) = unpack('>4I', buf[4:20])
  265.             ii = '>II'
  266.         else:
  267.             raise IOError(0, 'Bad magic number', filename)
  268.         for i in xrange(0, msgcount):
  269.             (mlen, moff) = unpack(ii, buf[masteridx:masteridx + 8])
  270.             mend = moff + mlen
  271.             (tlen, toff) = unpack(ii, buf[transidx:transidx + 8])
  272.             tend = toff + tlen
  273.             if mend < buflen and tend < buflen:
  274.                 msg = buf[moff:mend]
  275.                 tmsg = buf[toff:tend]
  276.             else:
  277.                 raise IOError(0, 'File is corrupt', filename)
  278.             if mlen == 0:
  279.                 lastk = None
  280.                 k = None
  281.                 for item in tmsg.splitlines():
  282.                     item = item.strip()
  283.                     if not item:
  284.                         continue
  285.                     
  286.                     if ':' in item:
  287.                         (k, v) = item.split(':', 1)
  288.                         k = k.strip().lower()
  289.                         v = v.strip()
  290.                         self._info[k] = v
  291.                         lastk = k
  292.                     elif lastk:
  293.                         self._info[lastk] += '\n' + item
  294.                     
  295.                     if k == 'content-type':
  296.                         self._charset = v.split('charset=')[1]
  297.                         continue
  298.                     if k == 'plural-forms':
  299.                         v = v.split(';')
  300.                         plural = v[1].split('plural=')[1]
  301.                         self.plural = c2py(plural)
  302.                         continue
  303.                 
  304.             
  305.             if '\x00' in msg:
  306.                 (msgid1, msgid2) = msg.split('\x00')
  307.                 tmsg = tmsg.split('\x00')
  308.                 for i in range(len(tmsg)):
  309.                     catalog[(msgid1, i)] = tmsg[i]
  310.                 
  311.             elif self._charset:
  312.                 msg = unicode(msg, self._charset)
  313.                 tmsg = unicode(tmsg, self._charset)
  314.             
  315.             catalog[msg] = tmsg
  316.             masteridx += 8
  317.             transidx += 8
  318.         
  319.  
  320.     
  321.     def gettext(self, message):
  322.         missing = object()
  323.         tmsg = self._catalog.get(message, missing)
  324.         if tmsg is missing:
  325.             if self._fallback:
  326.                 return self._fallback.gettext(message)
  327.             
  328.             return message
  329.         
  330.         if self._output_charset:
  331.             return tmsg.encode(self._output_charset)
  332.         elif self._charset:
  333.             return tmsg.encode(self._charset)
  334.         
  335.         return tmsg
  336.  
  337.     
  338.     def lgettext(self, message):
  339.         missing = object()
  340.         tmsg = self._catalog.get(message, missing)
  341.         if tmsg is missing:
  342.             if self._fallback:
  343.                 return self._fallback.lgettext(message)
  344.             
  345.             return message
  346.         
  347.         if self._output_charset:
  348.             return tmsg.encode(self._output_charset)
  349.         
  350.         return tmsg.encode(locale.getpreferredencoding())
  351.  
  352.     
  353.     def ngettext(self, msgid1, msgid2, n):
  354.         
  355.         try:
  356.             tmsg = self._catalog[(msgid1, self.plural(n))]
  357.             if self._output_charset:
  358.                 return tmsg.encode(self._output_charset)
  359.             elif self._charset:
  360.                 return tmsg.encode(self._charset)
  361.             
  362.             return tmsg
  363.         except KeyError:
  364.             if self._fallback:
  365.                 return self._fallback.ngettext(msgid1, msgid2, n)
  366.             
  367.             if n == 1:
  368.                 return msgid1
  369.             else:
  370.                 return msgid2
  371.         except:
  372.             n == 1
  373.  
  374.  
  375.     
  376.     def lngettext(self, msgid1, msgid2, n):
  377.         
  378.         try:
  379.             tmsg = self._catalog[(msgid1, self.plural(n))]
  380.             if self._output_charset:
  381.                 return tmsg.encode(self._output_charset)
  382.             
  383.             return tmsg.encode(locale.getpreferredencoding())
  384.         except KeyError:
  385.             if self._fallback:
  386.                 return self._fallback.lngettext(msgid1, msgid2, n)
  387.             
  388.             if n == 1:
  389.                 return msgid1
  390.             else:
  391.                 return msgid2
  392.         except:
  393.             n == 1
  394.  
  395.  
  396.     
  397.     def ugettext(self, message):
  398.         missing = object()
  399.         tmsg = self._catalog.get(message, missing)
  400.         if tmsg is missing:
  401.             if self._fallback:
  402.                 return self._fallback.ugettext(message)
  403.             
  404.             return unicode(message)
  405.         
  406.         return tmsg
  407.  
  408.     
  409.     def ungettext(self, msgid1, msgid2, n):
  410.         
  411.         try:
  412.             tmsg = self._catalog[(msgid1, self.plural(n))]
  413.         except KeyError:
  414.             if self._fallback:
  415.                 return self._fallback.ungettext(msgid1, msgid2, n)
  416.             
  417.             if n == 1:
  418.                 tmsg = unicode(msgid1)
  419.             else:
  420.                 tmsg = unicode(msgid2)
  421.         except:
  422.             n == 1
  423.  
  424.         return tmsg
  425.  
  426.  
  427.  
  428. def find(domain, localedir = None, languages = None, all = 0):
  429.     if localedir is None:
  430.         localedir = _default_localedir
  431.     
  432.     if languages is None:
  433.         languages = []
  434.         for envar in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
  435.             val = os.environ.get(envar)
  436.             if val:
  437.                 languages = val.split(':')
  438.                 break
  439.                 continue
  440.         
  441.         if 'C' not in languages:
  442.             languages.append('C')
  443.         
  444.     
  445.     nelangs = []
  446.     for lang in languages:
  447.         for nelang in _expand_lang(lang):
  448.             if nelang not in nelangs:
  449.                 nelangs.append(nelang)
  450.                 continue
  451.         
  452.     
  453.     if all:
  454.         result = []
  455.     else:
  456.         result = None
  457.     for lang in nelangs:
  458.         if lang == 'C':
  459.             break
  460.         
  461.         mofile = os.path.join(localedir, lang, 'LC_MESSAGES', '%s.mo' % domain)
  462.         if os.path.exists(mofile):
  463.             if all:
  464.                 result.append(mofile)
  465.             else:
  466.                 return mofile
  467.         all
  468.     
  469.     return result
  470.  
  471. _translations = { }
  472.  
  473. def translation(domain, localedir = None, languages = None, class_ = None, fallback = False, codeset = None):
  474.     if class_ is None:
  475.         class_ = GNUTranslations
  476.     
  477.     mofiles = find(domain, localedir, languages, all = 1)
  478.     if not mofiles:
  479.         if fallback:
  480.             return NullTranslations()
  481.         
  482.         raise IOError(ENOENT, 'No translation file found for domain', domain)
  483.     
  484.     result = None
  485.     for mofile in mofiles:
  486.         key = os.path.abspath(mofile)
  487.         t = _translations.get(key)
  488.         if t is None:
  489.             t = _translations.setdefault(key, class_(open(mofile, 'rb')))
  490.         
  491.         t = copy.copy(t)
  492.         if codeset:
  493.             t.set_output_charset(codeset)
  494.         
  495.         if result is None:
  496.             result = t
  497.             continue
  498.         result.add_fallback(t)
  499.     
  500.     return result
  501.  
  502.  
  503. def install(domain, localedir = None, unicode = False, codeset = None, names = None):
  504.     t = translation(domain, localedir, fallback = True, codeset = codeset)
  505.     t.install(unicode, names)
  506.  
  507. _localedirs = { }
  508. _localecodesets = { }
  509. _current_domain = 'messages'
  510.  
  511. def textdomain(domain = None):
  512.     global _current_domain
  513.     if domain is not None:
  514.         _current_domain = domain
  515.     
  516.     return _current_domain
  517.  
  518.  
  519. def bindtextdomain(domain, localedir = None):
  520.     if localedir is not None:
  521.         _localedirs[domain] = localedir
  522.     
  523.     return _localedirs.get(domain, _default_localedir)
  524.  
  525.  
  526. def bind_textdomain_codeset(domain, codeset = None):
  527.     if codeset is not None:
  528.         _localecodesets[domain] = codeset
  529.     
  530.     return _localecodesets.get(domain)
  531.  
  532.  
  533. def dgettext(domain, message):
  534.     
  535.     try:
  536.         t = translation(domain, _localedirs.get(domain, None), codeset = _localecodesets.get(domain))
  537.     except IOError:
  538.         return message
  539.  
  540.     return t.gettext(message)
  541.  
  542.  
  543. def ldgettext(domain, message):
  544.     
  545.     try:
  546.         t = translation(domain, _localedirs.get(domain, None), codeset = _localecodesets.get(domain))
  547.     except IOError:
  548.         return message
  549.  
  550.     return t.lgettext(message)
  551.  
  552.  
  553. def dngettext(domain, msgid1, msgid2, n):
  554.     
  555.     try:
  556.         t = translation(domain, _localedirs.get(domain, None), codeset = _localecodesets.get(domain))
  557.     except IOError:
  558.         if n == 1:
  559.             return msgid1
  560.         else:
  561.             return msgid2
  562.     except:
  563.         n == 1
  564.  
  565.     return t.ngettext(msgid1, msgid2, n)
  566.  
  567.  
  568. def ldngettext(domain, msgid1, msgid2, n):
  569.     
  570.     try:
  571.         t = translation(domain, _localedirs.get(domain, None), codeset = _localecodesets.get(domain))
  572.     except IOError:
  573.         if n == 1:
  574.             return msgid1
  575.         else:
  576.             return msgid2
  577.     except:
  578.         n == 1
  579.  
  580.     return t.lngettext(msgid1, msgid2, n)
  581.  
  582.  
  583. def gettext(message):
  584.     return dgettext(_current_domain, message)
  585.  
  586.  
  587. def lgettext(message):
  588.     return ldgettext(_current_domain, message)
  589.  
  590.  
  591. def ngettext(msgid1, msgid2, n):
  592.     return dngettext(_current_domain, msgid1, msgid2, n)
  593.  
  594.  
  595. def lngettext(msgid1, msgid2, n):
  596.     return ldngettext(_current_domain, msgid1, msgid2, n)
  597.  
  598. Catalog = translation
  599.